"use strict";

var _marked =
/*#__PURE__*/
regeneratorRuntime.mark(fibs);

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var a = 1,
    b = 2,
    c = 3;
console.log(a);
console.log(b);
console.log(c);
var foo = 1,
    bar = 2,
    baz = 3;
console.log(foo, bar, baz);
var _ref = ["foo", "bar", "baz"],
    third = _ref[2];
console.log(third);
var head = 1,
    tail = [2, 3, 4];
console.log(head);
console.log(tail);

var _ref2 = ['a'],
    x = _ref2[0],
    y = _ref2[1],
    z = _ref2.slice(2);

console.log(x);
console.log(y);
console.log(z);
var _ref3 = [],
    baa = _ref3[0];
var _ref4 = [1],
    bbb = _ref4[0],
    bba = _ref4[1]; // 上面都是可以结构成功
// 因为值为undefined
// 不完全结构
// let [x, y] = [1,2,3];
// let [a, [b], d] = [1,[ 2, 3], 4];

/** 
 * // 报错
let [foo] = 1;
let [foo] = false;
let [foo] = NaN;
let [foo] = undefined;
let [foo] = null;
let [foo] = {};
 * */
// 上面的语句都会报错，因为等号右边的值，要么转为对象以后不具备 Iterator 接口
// （前五个表达式），要么本身就不具备 Iterator 接口（最后一个表达式）。

var _ref5 = new Set(['a', 'b', 'c']),
    _ref6 = _slicedToArray(_ref5, 3),
    xx = _ref6[0],
    yy = _ref6[1],
    zz = _ref6[2];

console.log(xx);
console.log(yy);
console.log(zz); // 事实上，只要某种数据结构具有 Iterator 接口，都可以采用数组形式的解构赋值。

function fibs() {
  var a, b, _ref7;

  return regeneratorRuntime.wrap(function fibs$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          a = 0;
          b = 1;

        case 2:
          if (!true) {
            _context.next = 10;
            break;
          }

          _context.next = 5;
          return a;

        case 5:
          _ref7 = [b, a + b];
          a = _ref7[0];
          b = _ref7[1];
          _context.next = 2;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

var _fibs = fibs(),
    _fibs2 = _slicedToArray(_fibs, 6),
    first = _fibs2[0],
    second = _fibs2[1],
    third1 = _fibs2[2],
    fourth = _fibs2[3],
    fifth = _fibs2[4],
    sixth = _fibs2[5];

console.log(first, second, third1, fourth, fifth, sixth); //   默认
// let [foo = true] = [];
// let [x, y = 'b'] = ['a'];
// let [x, y = 'b'] = ['a', undefined]
// 注意，ES6 内部使用严格相等运算符（===），判断一个位置是否有值。
// 所以，只有当一个数组成员严格等于undefined，默认值才会生效
// let [x = 1] = [undefined];
// x // 1
// let [x = 1] = [null];
// x // null
// 上面代码中，
// 如果一个数组成员是null，默认值就不会生效，因为null不严格等于undefined。
// 默认值可以引用解构赋值的其他变量，但该变量必须已经声明。
// let [x = 1, y = x] = [];     // x=1; y=1
// let [x = 1, y = x] = [2];    // x=2; y=2
// let [x = 1, y = x] = [1, 2]; // x=1; y=2
// let [x = y, y = 1] = [];     // ReferenceError: y is not defined
// 对象的解构赋值

var _dd$cc = {
  dd: 'dd',
  cc: 'cc'
},
    dd = _dd$cc.dd,
    cc = _dd$cc.cc;
console.log(dd);
console.log(cc); // 对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；
// 而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。
// let { bar, foo } = { foo: 'aa', bar: 'bbb' }
// foo=>'aa'
// bar=>'bbb'
// let { baz } = { foo: "aaa", bar: "bbb" };
// baz // undefined
// 如果变量名与属性名不一致，必须写成下面这样。
// let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
// baz // "aaa"
// let obj = { first: 'hello', last: 'world' };
// let { first: f, last: l } = obj;
// f // 'hello'
// l // 'world'
// 这实际上说明，对象的解构赋值是下面形式的简写
// let { foo: foo, bar: bar } = { foo: "aaa", bar: "bbb" };
// 上面代码中，foo是匹配的模式，baz才是变量。
// 真正被赋值的是变量baz，而不是模式foo。

var obj = {
  p: ['Hello', {
    y1: 'World'
  }]
};

var p = obj.p,
    _obj$p = _slicedToArray(obj.p, 2),
    x1 = _obj$p[0],
    y1 = _obj$p[1].y1;

var node = {
  loc: {
    start: {
      line: 1,
      column: 5
    }
  }
};
var loc = node.loc,
    start = node.loc.start,
    line = node.loc.start.line;
console.log(line); // 1

console.log(loc); // Object {start: Object}

console.log(start); // Object {line: 1, column: 5}

var obj1 = {};
var arr = [];
var _foo$bar = {
  foo: 123,
  bar: true
};
obj1.prop = _foo$bar.foo;
arr[0] = _foo$bar.bar;
console.log(obj1); // {prop:123}

console.log(arr); // [true]
// 对象的解构也可以指定默认值。

/*
var {x = 3} = {};
x // 3

var {x, y = 5} = {x: 1};
x // 1
y // 5

var {x: y = 3} = {};
y // 3

var {x: y = 3} = {x: 5};
y // 5

var { message: msg = 'Something went wrong' } = {};
msg // "Something went wrong"
*/
// 默认值生效的条件是，对象的属性值严格等于undefined。

/*
var {x = 3} = {x: undefined};
x // 3

var {x = 3} = {x: null};
x // null
*/
// 如果要将一个已经声明的变量用于解构赋值，必须非常小心。
// 错误的写法
// let x;
// {x} = {x: 1};
// SyntaxError: syntax error

/*
上面代码的写法会报错，因为 JavaScript 引擎会将{x}理解成一个代码块，
从而发生语法错误。只有不将大括号写在行首，
避免 JavaScript 将其解释为代码块，才能解决这个问题
*/
// // 正确的写法
// let x;
// ({x} = {x: 1});

var log = Math.log,
    sin = Math.sin,
    cos = Math.cos;
console.log(log);
console.log(sin);
console.log(cos);
/*
let arr = [1, 2, 3];
let {0 : first, [arr.length - 1] : last} = arr;
first // 1
last // 3
*/
// 字符串的解构赋值

/*
const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"
*/
// 类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。

var _hello = 'hello',
    len = _hello.length;
console.log(len); // 5
// 数值和布尔值的解构赋值
// 解构赋值时，如果等号右边是数值和布尔值，则会先转为对象。

var _ = 123,
    s = _.toString;
console.log(s === Number.prototype.toString); // true
// let {toString: s} = true;
// s === Boolean.prototype.toString // true
